package com.rd.common.utils;

import cn.hutool.core.codec.Base64;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * Base64 头像存储工具类
 * 用于将 Base64 格式的头像保存到文件系统
 */
@Slf4j
@Component
public class AvatarBase64Util {

    /**
     * 头像存储根目录
     */
    private static final String AVATAR_ROOT_DIR = "/usr/local/software/avatar";

    /**
     * Web访问路径前缀
     */
    private static final String WEB_AVATAR_PREFIX = "/avatar/";

    /**
     * 保存 Base64 头像
     *
     * @param base64Data Base64 编码的头像数据
     * @param userId     用户ID
     * @return 本地文件路径，如果保存失败返回null
     */
    public static String saveBase64Avatar(String base64Data, String userId) {
        if (StrUtil.isBlank(base64Data)) {
            log.warn("Base64头像数据为空，跳过保存");
            return null;
        }

        if (StrUtil.isBlank(userId)) {
            log.warn("用户ID为空，跳过保存");
            return null;
        }

        try {
            // 确保根目录存在
            createAvatarRootDirectory();

            // 生成唯一文件名
            String fileName = generateFileName(userId);
            String localPath = AVATAR_ROOT_DIR + File.separator + fileName;

            // 解码并保存文件
            boolean success = saveBase64ToFile(base64Data, localPath);
            if (success) {
                log.info("Base64头像保存成功: {}", localPath);
                return localPath;
            } else {
                log.error("Base64头像保存失败");
                return null;
            }
        } catch (Exception e) {
            log.error("保存Base64头像时发生异常", e);
            return null;
        }
    }

    /**
     * 创建头像根目录
     */
    private static void createAvatarRootDirectory() {
        Path path = Paths.get(AVATAR_ROOT_DIR);
        if (!Files.exists(path)) {
            FileUtil.mkdir(path);
            log.info("创建头像根目录: {}", AVATAR_ROOT_DIR);
        }
    }

    /**
     * 生成包含用户ID的唯一文件名
     *
     * @param userId 用户ID
     * @return 文件名
     */
    private static String generateFileName(String userId) {
        // 使用用户ID作为文件名前缀，确保唯一性
        return userId + "_" + IdUtil.fastSimpleUUID() + ".jpg";
    }

    /**
     * 将 Base64 数据保存为文件
     *
     * @param base64Data Base64 编码的数据
     * @param localPath  本地保存路径
     * @return 是否保存成功
     */
    private static boolean saveBase64ToFile(String base64Data, String localPath) {
        try {
            // 移除 Base64 前缀（如果存在）
            String cleanBase64 = removeBase64Prefix(base64Data);
            
            // 解码 Base64 数据
            byte[] imageData = Base64.decode(cleanBase64);
            
            // 保存文件
            FileUtil.writeBytes(imageData, localPath);
            
            // 检查文件是否保存成功
            File file = new File(localPath);
            if (file.exists() && file.length() > 0) {
                log.info("Base64头像文件保存成功，大小: {} bytes", file.length());
                return true;
            } else {
                log.error("Base64头像文件保存失败，文件不存在或大小为0");
                return false;
            }
        } catch (Exception e) {
            log.error("保存Base64头像文件时发生异常: {}", localPath, e);
            return false;
        }
    }

    /**
     * 移除 Base64 前缀
     * 例如：... -> /9j/4AAQSkZJRgABAQAAAQ...
     *
     * @param base64Data 原始 Base64 数据
     * @return 清理后的 Base64 数据
     */
    private static String removeBase64Prefix(String base64Data) {
        if (StrUtil.isBlank(base64Data)) {
            return base64Data;
        }
        
        // 检查是否包含 data:image 前缀
        if (base64Data.contains("data:image")) {
            int base64Index = base64Data.indexOf("base64,");
            if (base64Index != -1) {
                return base64Data.substring(base64Index + 7);
            }
        }
        
        return base64Data;
    }

    /**
     * 将本地文件路径转换为Web访问路径
     *
     * @param localPath 本地文件路径
     * @return Web访问路径
     */
    public static String convertToWebPath(String localPath) {
        if (StrUtil.isBlank(localPath)) {
            return null;
        }

        // 提取文件名
        String fileName = new File(localPath).getName();
        // 转换为Web路径
        return WEB_AVATAR_PREFIX + fileName;
    }

    /**
     * 删除头像文件
     *
     * @param localPath 本地文件路径
     * @return 是否删除成功
     */
    public static boolean deleteAvatar(String localPath) {
        if (StrUtil.isBlank(localPath)) {
            return false;
        }

        try {
            File file = new File(localPath);
            if (file.exists()) {
                boolean deleted = FileUtil.del(file);
                if (deleted) {
                    log.info("删除头像文件成功: {}", localPath);
                    return true;
                } else {
                    log.warn("删除头像文件失败: {}", localPath);
                    return false;
                }
            } else {
                log.warn("头像文件不存在: {}", localPath);
                return true; // 文件不存在也算删除成功
            }
        } catch (Exception e) {
            log.error("删除头像文件时发生异常: {}", localPath, e);
            return false;
        }
    }

    /**
     * 检查文件是否存在
     *
     * @param localPath 本地文件路径
     * @return 文件是否存在
     */
    public static boolean fileExists(String localPath) {
        if (StrUtil.isBlank(localPath)) {
            return false;
        }
        return FileUtil.exist(localPath);
    }
} 